home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 21 / Cream of the Crop 21 (Terry Blount) (October 1996).iso / program / libkb100.zip / LIBKB-1.00 / SAMPLES / TUBE.C < prev    next >
C/C++ Source or Header  |  1996-07-23  |  12KB  |  572 lines
  1. /* tube.c -- test program for libkb with graphic and sound libraries
  2.  * Copyright (C) Markus F.X.J. Oberhumer and James Johnson
  3.  * For conditions of distribution and use, see copyright notice in kb.h 
  4.  */
  5.  
  6.  
  7. /* note: There is not much keyboard action in this program.
  8.  *       This is mainly a demonstration of the safety features of
  9.  *       libkb when allocating hardware resources.
  10.  */
  11.  
  12.  
  13. /* note: I've made many changes to this program, original info follows */
  14.  
  15. /*************************************************************************
  16.     Program    : Tubular
  17.     File    : tube.cpp
  18.     
  19.     Programmer    : James Johnson <plexus@stein.u.washington.edu>
  20.     Date        : 1-14-94
  21.     Version        : 1.0
  22.  ************************************************************************/
  23.  
  24.  
  25. #if defined(__EMX__)
  26. #  include <sys/emx.h>
  27. #endif
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <ctype.h>
  31. #include <time.h>
  32. #include <math.h>
  33. #include <signal.h>
  34. #include <assert.h>
  35. #include <string.h>
  36.  
  37. #include <kb.h>
  38. #if defined(__KB_MSDOS)
  39. #  include "_kb.h"                    /* KB_INT86, KB_INP8, KB_OUTP8 */
  40. #endif
  41. #include "intro.h"
  42.  
  43. #if defined(__KB_LINUX)
  44. #  define stricmp    strcasecmp        /* why is this missing ??? */
  45. #endif
  46.  
  47. #if !defined(__inline__) && !defined(__GNUC__)
  48. #  if defined(__cplusplus)
  49. #    define __inline__        inline
  50. #  else
  51. #    define __inline__        /* nothing */
  52. #  endif
  53. #endif
  54.  
  55.  
  56. static int in_graphics = 0;
  57. static int in_sound = 0;
  58.  
  59. static int is_win = -1;
  60.  
  61.  
  62. #include "tube.h"
  63.  
  64.  
  65. /***********************************************************************
  66. // Standalone BogoMips program v1.3 by Jeff Tranter
  67. //
  68. // Based on code Linux kernel code in init/main.c and
  69. // include/linux/delay.h
  70. //
  71. // For more information on interpreting the results,
  72. // see the BogoMIPS Mini-HOWTO document.
  73. ************************************************************************/
  74.  
  75. /* portable version */
  76. static void bogo_delay(long loops)
  77. {
  78.     long i;
  79.     for (i = loops; i >= 0 ; i--)
  80.         ;
  81. }
  82.  
  83.  
  84. /* return 33.55 BogoMips as 3355 */
  85. long bogomips(long min_interval_msec)
  86. {
  87.     clock_t ticks, min_ticks;
  88.     unsigned long loops_per_sec = 1;
  89.  
  90.     if (min_interval_msec < 10)        /* at least 10 millisecs */
  91.         min_interval_msec = 10;
  92.  
  93.     min_ticks = (min_interval_msec * (long)(CLOCKS_PER_SEC)) / 1000;
  94.     if (min_ticks < 2)
  95.         min_ticks = 2;
  96.  
  97.     while ((loops_per_sec <<= 1) != 0)
  98.     {
  99.         ticks = clock();
  100.         bogo_delay(loops_per_sec);
  101.         ticks = clock() - ticks;
  102.         if (ticks >= min_ticks)
  103.               return ((loops_per_sec / ticks) * (long)(CLOCKS_PER_SEC)) / 5000;
  104.     }
  105.     return -1;
  106. }
  107.  
  108.  
  109. long print_bogomips(FILE *f, long min_interval_msec)
  110. {
  111.     long bm;
  112.  
  113.     fprintf(f,"Calibrating delay loop.. ");
  114.     fflush(f);
  115.     bm = bogomips(min_interval_msec);
  116.     if (bm <= 0)
  117.         fprintf(f,"failed\n");
  118.     else
  119.         fprintf(f,"ok - %lu.%02lu BogoMips\n", bm / 100, bm % 100);
  120.     fflush(f);
  121.     return bm;
  122. }
  123.  
  124.  
  125. /***********************************************************************
  126. //
  127. ************************************************************************/
  128.  
  129. #ifndef M_PI
  130. #define M_PI        3.14159265358979323846
  131. #endif
  132.  
  133. #define Min_Z        (1  << 3)                /* color  1 */
  134. #define Max_Z       ((64 << 3) - 1)            /* color 63 */
  135. #define Min_Dz      2
  136. #define Max_Dz      64
  137. #define Def_DZ        3
  138. #define Step        20
  139. #define Max_Rand    256
  140. #define Max_Active    ((Max_Z / 2) * Step)
  141.  
  142. typedef struct
  143. {
  144.     int x;
  145.     int y;
  146.     int z;
  147.     int Old_x;
  148.     int Old_y;
  149.     int xc;
  150.     int yc;
  151. }
  152. Star;
  153.  
  154. #if defined(__KB_MSDOS16)
  155. typedef Star huge *PStar;
  156. static huge Star star[Max_Active];
  157. #else
  158. typedef Star *PStar;
  159. static Star star[Max_Active];
  160. #endif
  161.  
  162. static int Xtable[Max_Rand];
  163. static int Ytable[Max_Rand];
  164. static int Index[Max_Rand];
  165.  
  166.  
  167. /* setup colors - lowest z value is nearest star (should be brightest) */
  168. /* play around - this really changes the way it looks */
  169. /* colors 64-255 are not used, so you can still add plenty of stuff */
  170.  
  171. void initpal(void)
  172. {
  173.     int i;
  174.  
  175.     setcolor(0,0,0,15);
  176.     for (i = 1; i < 64; i++)
  177.     {
  178. #if 1
  179.         int tmp = (int) (pow(64.0,(48-i)/48.0) + 0.5);
  180.         if (tmp > 63)
  181.             tmp = 63;
  182.         else if (tmp < 1)
  183.             tmp = 1;
  184. #else
  185.         unsigned tmp = (unsigned) (pow(64,i/48.0) + 0.5);
  186.         tmp = (tmp > 63) ? 63 : tmp;
  187.         tmp = 63 - tmp;
  188. #endif
  189.         setcolor(i, tmp, tmp, (tmp < 15) ? 15 : tmp);
  190.     }
  191. }        
  192.                         
  193.  
  194. /***********************************************************************
  195. // init and draw the tube
  196. ************************************************************************/
  197.  
  198. static void init(void)
  199. {
  200.     int i, k, tmp;
  201.     unsigned Randnum;
  202.  
  203.     for (i = 0; i < Max_Active; i++)
  204.         star[i].z = 0;
  205.  
  206.     for (i = 0; i < Max_Rand; i++)
  207.     {
  208.         Xtable[i] = (int)(128 * cos(i * 2*M_PI / Max_Rand) + 0.5); 
  209.         Ytable[i] = (int)(128 * sin(i * 2*M_PI / Max_Rand) + 0.5);
  210.         Index[i] = i;
  211.     }
  212.     
  213.     /* shuffle Index[] */
  214.     for (k = 0; k < Max_Rand/2; k++)
  215.         for (i = 0; i < Max_Rand; i++)
  216.         {
  217.             Randnum = rand() % Max_Rand;
  218.             tmp = Index[Randnum];
  219.             Index[Randnum] = Index[i];
  220.             Index[i] = tmp;
  221.         }
  222. }
  223.                 
  224.  
  225. static unsigned long doit(void)
  226. {
  227.     int i, k;
  228.     int dz                = Def_DZ;
  229.     unsigned Tube_Xr    = 60;
  230.     unsigned Tube_Yr    = 60;
  231.     unsigned X_choice    = 0;
  232.     unsigned Y_choice    = 0;
  233.     unsigned X_count    = 64;
  234.     unsigned Y_count    = 0;
  235.     unsigned D_tube_xr    = 64;
  236.     unsigned D_tube_yr    = 0;
  237.     int Num_Active        = 0;
  238.     int First_Free      = 0;
  239.     unsigned count        = 0;
  240.     unsigned long frames = 0;
  241.  
  242.     for (;;)
  243.     {
  244. #if defined(USE_MIKMOD)
  245.         if (in_sound && mod)
  246.         {
  247.             MD_Update();
  248.             if (MP_Ready())
  249.                 MikMod_PlayMod(mod);    /* restart the MOD */
  250.         }
  251. #endif
  252.  
  253.     /* fill in new stars */
  254.         i = First_Free;
  255.         for (k = 0; k < Step && Num_Active < Max_Active; k++)
  256.         {
  257.             while (star[i].z != 0)
  258.                 i++;
  259.             star[i].x = Tube_Xr * Xtable[Index[X_choice]];
  260.             star[i].y = Tube_Yr * Ytable[Index[Y_choice]];
  261.             star[i].z = Max_Z;
  262.             star[i].xc = WIDTH/2  + (120 * Xtable[X_count]) / Max_Rand;
  263.             star[i].yc = HEIGHT/2 + ( 80 * Ytable[Y_count]) / Max_Rand;
  264.                 
  265.             if (++X_choice >= Max_Rand)
  266.                 X_choice = 0;
  267.             if (++Y_choice >= Max_Rand)
  268.                 Y_choice = 0;
  269.                 
  270.             Num_Active++;
  271.             i++;
  272.         }
  273.             
  274.     /* move stars */
  275.  
  276. #if defined(__DJGPP__) && !defined(USE_ALLEGRO)
  277.         _farsetsel(_dos_ds);    /* set selector for VIDMEM */
  278. #endif
  279.         for (i = 0; i < Max_Active; i++)
  280.         {
  281.             PStar s = &star[i];
  282.  
  283.             if (s->z == 0)    /* star is not active */
  284.                 continue;
  285.  
  286.              if (s->z > Min_Z)
  287.             {
  288.                 /* calculate the new one */
  289.                 int X_tmp = s->x / s->z + s->xc;
  290.                 
  291.                 /* if x lies within boundaries */
  292.                 if (X_tmp >= 0 && X_tmp < WIDTH)
  293.                 {
  294.                     int Y_tmp = s->y / s->z + s->yc;
  295.                     
  296.                     /* if y lies within boundaries.*/
  297.                     if (Y_tmp >= 0 && Y_tmp < HEIGHT)
  298.                     {
  299.                         if (X_tmp != s->Old_x || Y_tmp != s->Old_y)
  300.                         {
  301.                             /* erase the old star */
  302.                             setpixel(s->Old_x,s->Old_y,0);
  303.                             /* draw new star */
  304.                             s->Old_x = X_tmp;
  305.                             s->Old_y = Y_tmp;
  306.                             setpixel(X_tmp,Y_tmp,s->z >> 3);
  307.                         }
  308.                         s->z -= dz;
  309.  
  310.                         continue;        /* <- done */
  311.                     }
  312.                 }
  313.             }
  314.  
  315.             /* erase the old star */
  316.             setpixel(s->Old_x,s->Old_y,0);
  317.  
  318.             /* remove the star */
  319.             s->z = 0;
  320.             Num_Active--;
  321.             if (i < First_Free)
  322.                 First_Free = i;
  323.         }
  324.         
  325.         X_count += 2;
  326.         if (X_count >= Max_Rand) X_count = 0;
  327.         Y_count++;
  328.         if (Y_count >= Max_Rand) Y_count = 0;
  329.             
  330.     /* this section increases the X and Y radii, giving ellipses */
  331.         if (++count >= 5)
  332.         {
  333.             count = 0;
  334.             Tube_Xr = 20 * Xtable[D_tube_xr] / Max_Rand + 60;
  335.             Tube_Yr = 20 * Ytable[D_tube_yr] / Max_Rand + 60;
  336.             if(++D_tube_xr >= Max_Rand) D_tube_xr = 0;
  337.             if(++D_tube_yr >= Max_Rand) D_tube_yr = 0;
  338.         }
  339.  
  340.         frames++;
  341.  
  342.     /* handle keys */
  343.         if (kb_mode() && (kb_key(KB_SCAN_ESC) || kb_key(KB_SCAN_Q)))
  344.             return frames;
  345.  
  346.         while (kb_kbhit())
  347.         {
  348.             int Factor;
  349.             unsigned key;
  350.  
  351.             Factor = dz >= 10 ? 2 : 1;
  352.             key = kb_getkey();
  353.             switch(key)
  354.             {
  355.             case 0x1b:        /* Esc */
  356.             case 'q':
  357.             case 'Q':
  358.                 return frames;
  359.             case '+':
  360.                 if (dz+Factor <= Max_Dz) dz += Factor;
  361.                 break;
  362.             case '-':
  363.                 if (dz-Factor >= Min_Dz) dz -= Factor;
  364.                 break;
  365. #if defined(USE_MIKMOD)
  366.             /* a little MOD-player :-) */
  367.             case 0x24b:        /* cursor left */
  368.                 if (in_sound && mod && !MP_Ready())
  369.                     if (mp_sngpos > 0)
  370.                         MP_PrevPosition();
  371.                 break;
  372.             case 0x24d:        /* cursor right */
  373.                 if (in_sound && mod && !MP_Ready())
  374.                     if (mp_sngpos < mod->numpos - 1)
  375.                         MP_NextPosition();
  376.                 break;
  377. #endif
  378.             }
  379.         }
  380.  
  381.  
  382.         /* could wait for retrace here... */
  383.         /* waitvrt();